// 云对象教程: https://uniapp.dcloud.net.cn/uniCloud/cloud-obj
// jsdoc语法提示教程：https://ask.dcloud.net.cn/docs/#//ask.dcloud.net.cn/article/129

const {
	debug
} = require("console");

const _db = uniCloud.database();
const db = uniCloud.databaseForJQL()
const dbCmd = db.command
const CryptoJS = require('crypto-js');
let addUserScoretime = 0;
module.exports = {
	_before: function() { // 通用预处理器
		// this.param = this.getParam();
		try {
			if (this.getHttpInfo().body) {
				this.param = JSON.parse(this.getHttpInfo().body);
				console.log("_before", this.getHttpInfo().body);
			}
		} catch (e) {
			console.log("获取参数异常:", JSON.stringify(e));
		}
	},

	/**
	 * method1方法描述
	 * @param {string} param1 参数1描述
	 * @returns {object} 返回值描述
	 */
	getAppKey: async function(param) {
		if (!this.param) {
			if (param) {
				this.param = param;
			}
		}
		const res = await db.collection('open-key').limit(1).get();
		const resStr = JSON.stringify(res);
		// 定义加密密钥，这里使用Base64编码的字符串
		let key = "KWJjZGVmZzEyMzQ1Njc4OQ==";
		// 将Base64编码的密钥解析为CryptoJS可识别的格式
		let keyBase64 = CryptoJS.enc.Base64.parse(key);
		// 初始化向量(IV)，这里使用空字符串的Utf8编码，通常IV应该是随机生成的，但这里为了示例使用空字符串 16位数字字符串
		let iv = CryptoJS.enc.Utf8.parse("");

		// 使用AES算法、CBC模式和PKCS#7填充对明文进行加密
		const encryptedData = CryptoJS.AES.encrypt(resStr, keyBase64, {
			iv: iv, // 使用上面定义的IV
			mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
		});
		// 将加密后的对象转换为字符串形式返回
		const encrypterStr = encryptedData.toString();

		if (encrypterStr.length > 0) {
			return {
				data: encrypterStr
			};
		} else {
			return {
				errCode: 409
			}
		}
	},
	/**
	 * method1方法描述
	 * @param {string} param1 参数1描述
	 * @returns {object} 返回值描述
	 */
	getGameList: async function(param) {
		if (!this.param) {
			if (param) {
				this.param = param;
			}
		}
		if (!this.param.data) {
			return {
				errCode: 409
			}
		}
		// 定义加密密钥，这里使用Base64编码的字符串
		let key = "KWJjZGVmZzEyMzQ1Njc4OQ==";
		// 将Base64编码的密钥解析为CryptoJS可识别的格式
		let keyBase64 = CryptoJS.enc.Base64.parse(key);
		// 初始化向量(IV)，这里使用空字符串的Utf8编码，通常IV应该是随机生成的，但这里为了示例使用空字符串 16位数字字符串
		let iv = CryptoJS.enc.Utf8.parse("");
		// 使用AES算法、CBC模式和PKCS#7填充对密文进行解密，并指定返回格式为Utf8字符串
		const decryptedData = CryptoJS.AES.decrypt(this.param.data, keyBase64, {
			iv: iv, // 使用上面定义的IV
			mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
		}).toString(CryptoJS.enc.Utf8);
		const queryParam = JSON.parse(decryptedData);
		if (!queryParam) {
			return {
				errCode: 409
			}
		}
		const res = await db.collection('guaguale-list').where(queryParam).orderBy('index asc').limit(100)
	.get();
		const resStr = JSON.stringify(res);

		// 使用AES算法、CBC模式和PKCS#7填充对明文进行加密
		const encryptedData = CryptoJS.AES.encrypt(resStr, keyBase64, {
			iv: iv, // 使用上面定义的IV
			mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
		});
		// 将加密后的对象转换为字符串形式返回
		const encrypterStr = encryptedData.toString();
		if (encrypterStr.length > 0) {
			return {
				data: encrypterStr
			};
		} else {
			return {
				errCode: 409
			}
		}
	},
	/**
	 * method1方法描述
	 * @param {string} param1 参数1描述
	 * @returns {object} 返回值描述
	 */
	updateUserInfo: async function(param) {
		if (!this.param) {
			if (param) {
				this.param = param;
			}
		}
		const openid = this.param.data;
		// 定义加密密钥，这里使用Base64编码的字符串
		let key = "KWJjZGVmZzEyMzQ1Njc4OQ==";
		// 将Base64编码的密钥解析为CryptoJS可识别的格式
		let keyBase64 = CryptoJS.enc.Base64.parse(key);
		// 初始化向量(IV)，这里使用空字符串的Utf8编码，通常IV应该是随机生成的，但这里为了示例使用空字符串 16位数字字符串
		let iv = CryptoJS.enc.Utf8.parse("");

		// 使用AES算法、CBC模式和PKCS#7填充对密文进行解密，并指定返回格式为Utf8字符串
		const decryptedData = CryptoJS.AES.decrypt(openid, keyBase64, {
			iv: iv, // 使用上面定义的IV
			mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
		}).toString(CryptoJS.enc.Utf8);
		const userInfo = JSON.parse(decryptedData);
		const {userid,datetime} = userInfo;
		console.log("更新用户信息参数: " + JSON.stringify(userInfo));
		if(!userid || !datetime) {
			console.log(userid,datetime);
			return {
				errCode: 309
			}
		}
		// 获取token
		const token = await db.collection('open-user-token').where({userid,datetime}).get()
		if(token.data.length>0){
			return {
				errCode: 409
			}
		}
		delete userInfo.userid;
		delete userInfo.datetime;
		console.log("userInfo: " + JSON.stringify(userInfo));
		if (userInfo && openid) {
			// 增加token
			await db.collection('open-user-token').add({userid,datetime});
			return db.collection('open_user').where({
				username: userInfo.username
			}).update(userInfo);
			
		} else {
			return {
				errCode: 509
			}
		}
	},

	/**
	 * method1方法描述
	 * @param {string} param1 参数1描述
	 * @returns {object} 返回值描述
	 */
	getUserInfo: async function(param) {
		if (!this.param) {
			if (param) {
				this.param = param;
			}
		}
		const openid = this.param.data;
		// 定义加密密钥，这里使用Base64编码的字符串
		let key = "KWJjZGVmZzEyMzQ1Njc4OQ==";
		// 将Base64编码的密钥解析为CryptoJS可识别的格式
		let keyBase64 = CryptoJS.enc.Base64.parse(key);
		// 初始化向量(IV)，这里使用空字符串的Utf8编码，通常IV应该是随机生成的，但这里为了示例使用空字符串 16位数字字符串
		let iv = CryptoJS.enc.Utf8.parse("");

		// 使用AES算法、CBC模式和PKCS#7填充对密文进行解密，并指定返回格式为Utf8字符串
		const decryptedData = CryptoJS.AES.decrypt(openid, keyBase64, {
			iv: iv, // 使用上面定义的IV
			mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
		}).toString(CryptoJS.enc.Utf8);
		console.log("openid:", decryptedData);
		if (decryptedData && decryptedData.length > 0) {
			return db.collection('open_user').where({
				username: decryptedData
			}).field("_id,score as score,avatar,nickname,updateuserdate,register_date").get();
			// // 使用AES算法、CBC模式和PKCS#7填充对明文进行加密
			// const encryptedData = CryptoJS.AES.encrypt(JSON.stringify(res), keyBase64, {
			// 	iv: iv, // 使用上面定义的IV
			// 	mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			// 	padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
			// });
			// return {
			// 	data: encryptedData
			// }
		} else {
			return {
				errCode: 409
			}
		}
	},

	/**
	 * method1方法描述
	 * @param {string} param1 参数1描述
	 * @returns {object} 返回值描述
	 */
	loginUser: async function(param) {
		if (!this.param) {
			if (param) {
				this.param = param;
			}
		}
		const openid = this.param.data;
		// 定义加密密钥，这里使用Base64编码的字符串
		let key = "KWJjZGVmZzEyMzQ1Njc4OQ==";
		// 将Base64编码的密钥解析为CryptoJS可识别的格式
		let keyBase64 = CryptoJS.enc.Base64.parse(key);
		// 初始化向量(IV)，这里使用空字符串的Utf8编码，通常IV应该是随机生成的，但这里为了示例使用空字符串 16位数字字符串
		let iv = CryptoJS.enc.Utf8.parse("");

		// 使用AES算法、CBC模式和PKCS#7填充对密文进行解密，并指定返回格式为Utf8字符串
		const decryptedData = CryptoJS.AES.decrypt(openid, keyBase64, {
			iv: iv, // 使用上面定义的IV
			mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
		}).toString(CryptoJS.enc.Utf8);
		console.log("openid:", decryptedData);
		if (decryptedData && decryptedData.length > 0) {
			return db.collection('open_user').where({
				username: decryptedData
			}).field("_id,username,score").get();
		} else {
			return {
				errCode: 409
			}
		}
	},
	registerUser: async function(param) {
		if (!this.param) {
			if (param) {
				this.param = param;
			}
		}
		const data = this.param.data;
		// 定义加密密钥，这里使用Base64编码的字符串
		let key = "KWJjZGVmZzEyMzQ1Njc4OQ==";
		// 将Base64编码的密钥解析为CryptoJS可识别的格式
		let keyBase64 = CryptoJS.enc.Base64.parse(key);
		// 初始化向量(IV)，这里使用空字符串的Utf8编码，通常IV应该是随机生成的，但这里为了示例使用空字符串 16位数字字符串
		let iv = CryptoJS.enc.Utf8.parse("");
		// 使用AES算法、CBC模式和PKCS#7填充对密文进行解密，并指定返回格式为Utf8字符串
		const decryptedData = CryptoJS.AES.decrypt(data, keyBase64, {
			iv: iv, // 使用上面定义的IV
			mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
		}).toString(CryptoJS.enc.Utf8);
		if (decryptedData && decryptedData.length > 0) {
			const userInfo = JSON.parse(decryptedData);
			if (userInfo) {
				return db.collection("open_user").add(userInfo);
			} else {
				return {
					errCode: 409
				}
			}
		} else {
			return {
				errCode: 409
			}
		}
	},
	addUserScoreHistory: async function(param) {
		if (!this.param) {
			if (param) {
				this.param = param;
			}
		}
		const data = this.param.data;
		if (!data) {
			return {
				errCode: 409
			}
		}
		// 定义加密密钥，这里使用Base64编码的字符串
		let key = "KWJjZGVmZzEyMzQ1Njc4OQ==";
		// 将Base64编码的密钥解析为CryptoJS可识别的格式
		let keyBase64 = CryptoJS.enc.Base64.parse(key);
		// 初始化向量(IV)，这里使用空字符串的Utf8编码，通常IV应该是随机生成的，但这里为了示例使用空字符串 16位数字字符串
		let iv = CryptoJS.enc.Utf8.parse("");

		// 使用AES算法、CBC模式和PKCS#7填充对密文进行解密，并指定返回格式为Utf8字符串
		const decryptedData = CryptoJS.AES.decrypt(data, keyBase64, {
			iv: iv, // 使用上面定义的IV
			mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
		}).toString(CryptoJS.enc.Utf8);
		
		console.log("decryptedData: " + decryptedData);
		if (decryptedData && decryptedData.length > 0) {
			const userScore = JSON.parse(decryptedData);
			const {userid,datetime} = userScore;
			console.log("更新用户信息参数: " + JSON.stringify(userScore));
			if(!userid || !datetime) {
				console.log(userid,datetime);
				return {
					errCode: 309
				}
			}
			// 获取token
			const token = await db.collection('open-user-token').where({userid,datetime}).get()
			if(token.data.length>0){
				return {
					errCode: 409
				}
			}
			console.log("userScore: " + JSON.stringify(userScore));
			if (userScore) {
				// 增加token
				await db.collection('open-user-token').add({userid,datetime});
				const now = new Date().getTime() - userScore.datetime;
				console.log(userScore.datetime+","+now);
				if(userScore.datetime && userScore.datetime != addUserScoretime && now < 10000){
					addUserScoretime = userScore.datetime
					return db.collection("guagua-userscore-new").add(userScore)
				}else{
					return {
						errCode: 509
					}
				}
			} else {
				return {
					errCode: 609
				}
			}
		} else {
			return {
				errCode: 709
			}
		}
	},
	/**
	 * 明文AES加密函数
	 * @param {String} plainText 需要加密的明文
	 * @returns {String} 加密后的密文字符串
	 */
	aesEncrypt: function(plainText) {
		// 如果传入的明文未定义，则直接返回
		if (plainText == undefined) {
			return plainText;
		}
		// 使用AES算法、CBC模式和PKCS#7填充对明文进行加密
		const encryptedData = CryptoJS.AES.encrypt(plainText, keyBase64, {
			iv: iv, // 使用上面定义的IV
			mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
		});
		// 将加密后的对象转换为字符串形式返回
		return encryptedData.toString();
	},

	/**
	 * 密文解密函数
	 * @param {String} cipherText 需要解密的密文字符串
	 * @returns {String} 解密后的明文字符串
	 */
	aesDecrypt: function(cipherText) {
		// 如果传入的密文未定义，则直接返回
		if (cipherText == undefined) {
			return cipherText;
		}
		// 使用AES算法、CBC模式和PKCS#7填充对密文进行解密，并指定返回格式为Utf8字符串
		const decryptedData = CryptoJS.AES.decrypt(cipherText, keyBase64, {
			iv: iv, // 使用上面定义的IV
			mode: CryptoJS.mode.CBC, // 加密模式设置为CBC
			padding: CryptoJS.pad.Pkcs7, // 填充方式设置为PKCS#7
		}).toString(CryptoJS.enc.Utf8);
		// 返回解密后的明文
		return decryptedData;
	}

}